home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 February / EnigmA AMIGA RUN 04 (1996)(G.R. Edizioni)(IT)[!][issue 1996-02][Skylink CD III].iso / earcd / util1 / yk211src.lha / Yak_2.11_Src / Prefs / BGUI / Keydef_window.c < prev    next >
C/C++ Source or Header  |  1995-11-16  |  21KB  |  528 lines
  1. /************************************************************************
  2. **********************  BGUI KEYDEFINITION WINDOW  **********************
  3. ************************************************************************/
  4.  
  5. #include <exec/types.h>
  6. #include <exec/memory.h>
  7. #include <dos/dosextens.h>
  8. #include <intuition/intuition.h>
  9. #include <intuition/classes.h>
  10. #include <intuition/classusr.h>
  11. #include <intuition/imageclass.h>
  12. #include <intuition/gadgetclass.h>
  13. #include <intuition/intuitionbase.h>
  14. #include <libraries/bgui.h>
  15. #include <libraries/bgui_macros.h>
  16. #include <libraries/commodities.h>
  17. #include <proto/commodities.h>
  18. #include <proto/exec.h>
  19. #include <proto/intuition.h>
  20. #include <proto/bgui.h>
  21. #include <proto/wb.h>
  22. #include <clib/alib_protos.h>
  23. #include <string.h>
  24.  
  25. #include "code.h"
  26. #include "version.h"
  27. #include "yak.h"
  28. #include "hotkey_types.h"
  29. #include "handlers.h"
  30. #include "keydef.h"
  31. #include "gui.h"
  32. #include "KeyDef_Window.h"
  33. #include "Requesters.h"
  34. #include "yak_locale_strings.h"
  35.  
  36. /************************************************************************
  37. *****************************  REFERENCES  ******************************
  38. ************************************************************************/
  39.  
  40. IMPORT LONG (*HandleReturnID)(LONG ID);
  41. IMPORT UBYTE ParentWindowID;
  42. IMPORT char *PrefsHelp;
  43.  
  44. extern void HookEntry(void);                    /* from amiga.lib */
  45.  
  46. /************************************************************************
  47. *****************************  PROTOTYPES  ******************************
  48. ************************************************************************/
  49.  
  50. static void InitHook(struct Hook *hook,ULONG (*hookfn)(),APTR data);
  51.  
  52. static SAVEDS ASM ULONG KeyDefWindowHandler(REG(a0) struct Hook *hook, REG(a2) void *obj, REG(a1) void *msg);
  53.  
  54. /************************************************************************
  55. *****************************  LOCAL DATA  ******************************
  56. ************************************************************************/
  57.  
  58. struct Window           *KeyDefWnd = NULL;
  59. Object                  *KeyDefWndObj = NULL;
  60. Object                  *KeyDefObjects[KeyDef_CNT];
  61. char                    *KeyDefWdt;
  62. struct IBox              KeyDefBox;
  63. BOOL                     KeyDefBoxValid = FALSE;
  64.  
  65. struct Hook              KeyDefWindowHook;
  66.  
  67. static APTR      CurObj;
  68. static YakKeyDef KeyDef;
  69.  
  70. UBYTE *Class0Labels[5];
  71. UBYTE *Stroke0Labels[4];
  72.  
  73. /************************************************************************
  74. *****************************  INITHOOK()  ******************************
  75. *************************************************************************
  76. * Initialize the hook struct supplied with the hook function and
  77. * (optional) hook data ptr.
  78. *
  79. *************************************************************************/
  80.  
  81. static void InitHook(struct Hook *hook,ULONG (*hookfn)(),APTR data)
  82. {
  83. hook->h_Entry = (ULONG (*)()) HookEntry;
  84. hook->h_SubEntry = hookfn;
  85. hook->h_Data = data;
  86. }
  87.  
  88. /************************************************************************
  89. ************************  CREATEKEYDEFWINDOW()  *************************
  90. *************************************************************************
  91. * Create the keydef window object tree. Returns the window object ptr or
  92. * NULL if create failed. Gadgets are initialised with default values,
  93. * InitKeyDefGadgets must be called after window opened to reflect current
  94. * settings.
  95. *
  96. *************************************************************************/
  97.  
  98. APTR CreateKeyDefWindow(VOID)
  99. {
  100. Object  *obj;
  101.  
  102. /* put localised strings into cycle gadget labels */
  103. Class0Labels[0] = getString(RawKey_CLASS);
  104. Class0Labels[1] = getString(RawMouse_CLASS);
  105. Class0Labels[2] = getString(DiskInserted_CLASS);
  106. Class0Labels[3] = getString(DiskRemoved_CLASS);
  107. Class0Labels[4] = NULL;
  108.  
  109. Stroke0Labels[0] = getString(Down_STROKE);
  110. Stroke0Labels[1] = getString(Up_STROKE);
  111. Stroke0Labels[2] = getString(Down_Up_STROKE);
  112. Stroke0Labels[3] = NULL;
  113.  
  114. /* initialize the window idcmp hook */
  115. InitHook(&KeyDefWindowHook,KeyDefWindowHandler,NULL);
  116.  
  117. obj = WindowObject,
  118.         WINDOW_PubScreenName, PubScreenName,
  119.         WINDOW_Title,           KeyDefWdt,
  120.         WINDOW_ScreenTitle,     getString(COPYRIGHT_STRING),
  121.         WINDOW_SmartRefresh, TRUE,
  122.         WINDOW_SizeBottom,      FALSE,                  /* put size gadget in right border */
  123.         WINDOW_SizeRight,       TRUE,
  124.         WINDOW_AutoAspect,      TRUE,                   /* automatic edges pixel width */
  125.         WINDOW_Position,        POS_CENTERMOUSE,
  126.         (KeyDefBoxValid ? WINDOW_Bounds : TAG_IGNORE), &KeyDefBox,
  127.         WINDOW_AppWindow,       TRUE,                   /* make it an appwindow */
  128.         WINDOW_RMBTrap,         TRUE,                   /* trap rmb - no menu */
  129.         WINDOW_CloseGadget,     FALSE,                  /* no windowclose gadget please */
  130.         WINDOW_IDCMP,           IDCMP_MOUSEBUTTONS,     /* additional idcmp bits */
  131.         WINDOW_IDCMPHookBits, IDCMP_RAWKEY|IDCMP_MOUSEBUTTONS,
  132.         WINDOW_IDCMPHook,       &KeyDefWindowHook,
  133.         (TextFont ? WINDOW_Font : TAG_IGNORE),  &Attr,  /* use font if specified */
  134.         WINDOW_MasterGroup,
  135.                 VGroupObject, Spacing(4), HOffset(4), VOffset(4),
  136.                         StartMember,
  137.                                 HGroupObject, Spacing(8),
  138.                                         StartMember,
  139.                                                 CYC_Class = CycleObject,
  140.                                                         LAB_Label,              getString(CLASS_STRING),
  141.                                                         GA_ID,                  GD_Class,
  142.                                                         ButtonFrame,
  143.                                                         CYC_Labels,             Class0Labels,
  144.                                                         CYC_Active,             0,
  145.                                                         CYC_Popup,              TRUE,
  146.                                                 EndObject,
  147.                                         EndMember,
  148.                                         VarSpace(DEFAULT_WEIGHT/10),
  149.                                         StartMember,
  150.                                                 CYC_Stroke = CycleObject,
  151.                                                         LAB_Label,              getString(STROKE_STRING),
  152.                                                         GA_ID,                  GD_Stroke,
  153.                                                         ButtonFrame,
  154.                                                         CYC_Labels,             Stroke0Labels,
  155.                                                         CYC_Active,             0,
  156.                                                         CYC_Popup,              TRUE,
  157.                                                 EndObject,
  158.                                         EndMember,
  159.                                 EndObject,
  160.                         EndMember,
  161.                         VarSpace(DEFAULT_WEIGHT/10),
  162.                         StartMember,
  163.                                 STR_Desc = StringObject,
  164.                                         LAB_Label,              getString(DESC_STRING),
  165.                                         STRINGA_MaxChars,256,
  166.                                         GA_ID,                  GD_Desc,
  167.                                         RidgeFrame,
  168.                                 EndObject,
  169.                         EndMember,
  170.                         VarSpace(DEFAULT_WEIGHT/10),
  171.                         StartMember,
  172.                                 HorizSeparator,
  173.                         EndMember,
  174.                         StartMember,
  175.                                 HGroupObject, Spacing(2),
  176.                                         StartMember,
  177.                                                 BT_Ok = Button(getString(OK_STRING),GD_Ok),
  178.                                         EndMember,
  179.                                         VarSpace(DEFAULT_WEIGHT),
  180.                                         StartMember,
  181.                                                 BT_Clear = Button(getString(CLEAR_STRING),GD_Clear),
  182.                                         EndMember,
  183.                                         VarSpace(DEFAULT_WEIGHT),
  184.                                         StartMember,
  185.                                                 BT_Help = Button(getString(HELP_STRING),GD_Help),
  186.                                         EndMember,
  187.                                         VarSpace(DEFAULT_WEIGHT),
  188.                                         StartMember,
  189.                                                 BT_Cancel2 = Button(getString(CANCEL_STRING),GD_Cancel),
  190.                                         EndMember,
  191.                                 EndObject,
  192.                         EndMember,
  193.                 EndObject,
  194.         EndObject;
  195.  
  196. return(obj);
  197. }
  198.  
  199. /************************************************************************
  200. *************************  CLOSEKEYDEFWINDOW()  *************************
  201. *************************************************************************
  202. * Close the keydef window, disposing of the window object.
  203. *
  204. *************************************************************************/
  205.  
  206. void CloseKeyDefWindow(void)
  207. {
  208. if (KeyDefWnd)
  209.         {
  210.         GetAttr(WINDOW_Bounds,KeyDefWndObj,(ULONG *) &KeyDefBox);
  211.         KeyDefBoxValid = TRUE;
  212.         }
  213.  
  214. DisposeObject(KeyDefWndObj);
  215. KeyDefWndObj = NULL;
  216. KeyDefWnd = NULL;
  217.  
  218. /* Re-enable Yak now that our job is finished */
  219. BrokerCommand("Yak", CXCMD_ENABLE);
  220. }
  221.  
  222. /************************************************************************
  223. ************************  INITKEYDEFGADGETS()  **************************
  224. *************************************************************************
  225. * Initialize the keydef window gadgets to reflect current settings.
  226. * 
  227. *************************************************************************/
  228.  
  229. static void InitKeyDefGadgets(void)
  230. {
  231. UBYTE   SeqString[127];
  232. BOOL    SeqOk;
  233.  
  234. SeqOk = BuildKeyDef(&KeyDef, SeqString);
  235.  
  236. InitWindowGadget(GDX_Class, CYC_Active, KeyDef.ykd_Class, KEYDEF_WINDOW);
  237.  
  238. if (ParentWindowID == MCYCLING_WINDOW)
  239.         InitWindowGadget(GDX_Class, GA_Disabled, KeyDef.ykd_Class, KEYDEF_WINDOW);
  240.  
  241. InitWindowGadget(GDX_Desc,   STRINGA_TextVal, (LONG)SeqString,   KEYDEF_WINDOW);
  242. InitWindowGadget(GDX_Stroke, CYC_Active,      KeyDef.ykd_Stroke, KEYDEF_WINDOW);
  243. InitWindowGadget(GDX_Stroke, GA_Disabled,     KeyDef.ykd_Class,  KEYDEF_WINDOW);
  244. InitWindowGadget(GDX_Ok,     GA_Disabled,     !SeqOk,            KEYDEF_WINDOW);
  245. }
  246.  
  247. /************************************************************************
  248. ***********************  SWITCHTOKEYDEFWINDOW()  ************************
  249. *************************************************************************
  250. * Switch to keydef window from another window, which will be closed by
  251. * this routine. Supply the parent window ID, the object whose key
  252. * definition you want edited (YakHotKey if from hotkey window, YakHandler
  253. * if from Misc window), and an 'action' string which appears in the
  254. * window title (tells the user what s/he's editing). Returns TRUE or
  255. * FALSE to indicate success.
  256. *
  257. *************************************************************************/
  258.  
  259. BOOL SwitchToKeyDefWindow(UBYTE I_ParentWindowID, APTR I_object, char *I_action)
  260. {
  261. static char     title[80];
  262. char            *def;
  263.  
  264. strcpy(title, getString(KeyDef_Window_TITLE));
  265. strcat(title, " ");
  266. if (I_action)
  267.         strcat(title, I_action); 
  268. else
  269.         strcat(title, "<<unnamed>>"); 
  270. KeyDefWdt = title;
  271.  
  272. ParentWindowID = I_ParentWindowID;
  273. CurObj         = I_object;
  274.  
  275. if (ParentWindowID == HOTKEY_WINDOW)
  276.         def = ((YakHotKey *)CurObj)->yhk_KeyDef;
  277. else
  278.         def = ((YakHandler *)CurObj)->KeyDef;
  279.  
  280. ParseKeyDef(def, &KeyDef);
  281.  
  282. CloseWindowID(ParentWindowID);
  283.  
  284. return(ShowKeyDefWindow());
  285. }
  286.  
  287. /************************************************************************
  288. ***********************  HANDLEKEYDEFRETURNID()  ************************
  289. *************************************************************************
  290. * Handle msgs arriving at keydef window - supply the ID returned by
  291. * BGUI. Returns either RET_OKAY or RET_QUIT.
  292. *
  293. *************************************************************************/
  294.  
  295. LONG HandleKeyDefReturnID(LONG id)
  296. {
  297. LONG    ret;
  298. ULONG   code;
  299.  
  300. ret = RET_OKAY;
  301.  
  302. switch(id)
  303.         {
  304.         case GD_Class:
  305.                 GetAttr(CYC_Active,CYC_Class,&code);
  306.                 KeyDef.ykd_Class  = code;
  307.                 KeyDef.ykd_Stroke = HKSTROKE_DOWN;
  308.                 KeyDef.ykd_Code   = NO_IECODE;
  309.                 KeyDef.ykd_Qual = KeyDef.ykd_IQual = KeyDef.ykd_SQual = NO_IEQUALIFIER;
  310.                 InitKeyDefGadgets();
  311.                 break;
  312.  
  313.         case GD_Stroke:
  314.                 GetAttr(CYC_Active,CYC_Stroke,&code);
  315.                 if ((KeyDef.ykd_Stroke=code) == HKSTROKE_UP)
  316.                         {
  317.                         KeyDef.ykd_Qual  &= ~IEQUALIFIER_REPEAT;
  318.                         KeyDef.ykd_IQual &= ~IEQUALIFIER_REPEAT;
  319.                         }
  320.                 InitKeyDefGadgets();
  321.                 break;
  322.  
  323.         case GD_Desc:
  324.                 GetAttr(STRINGA_TextVal,STR_Desc,&code);
  325.                 if (ParseKeyDef((char *)code, &KeyDef) == -1)
  326.                         PostError(getString(Invalid_hotkey_specif_ERR));
  327.                 InitKeyDefGadgets();
  328.                 break;
  329.  
  330.         case GD_Cancel:
  331.                 CloseKeyDefWindow();
  332.                 if (!ShowWindowID(ParentWindowID))
  333.                         ret = RET_QUIT;
  334.                 break;
  335.  
  336.         case GD_Help:
  337.                 DisableYakInterface();
  338.                 BrokerCommand("Yak", CXCMD_ENABLE);
  339.                 BGUI_Help(KeyDefWnd, PrefsHelp, "Hotkey Description String",0);
  340.                 BrokerCommand("Yak", CXCMD_DISABLE);
  341.                 ActivateWindow(KeyDefWnd);
  342.                 EnableYakInterface();
  343.                 break;
  344.  
  345.         case GD_Clear:
  346.                 KeyDef.ykd_Stroke = HKSTROKE_DOWN;
  347.                 KeyDef.ykd_Code   = NO_IECODE;
  348.                 KeyDef.ykd_Qual   = KeyDef.ykd_IQual = KeyDef.ykd_SQual = NO_IEQUALIFIER;
  349.                 InitKeyDefGadgets();
  350.                 break;
  351.  
  352.         case GD_Ok:
  353.                 GetAttr(STRINGA_TextVal,STR_Desc,&code);
  354.                 if (ParentWindowID == HOTKEY_WINDOW)
  355.                         {
  356.                         if (ModifyYHKKeyDef(CurObj, (char *)code) == TRUE)
  357.                                 {
  358.                                 /* Turn hotkey on active by default */
  359.                                 ((YakHotKey *)CurObj)->yhk_State = YKHK_ACTIVE;
  360.                                 }
  361.                         }
  362.                 else
  363.                         {
  364.                         char            *newdef;
  365.                         YakHandler      *curhd;
  366.  
  367.                         if (newdef = DupStr((char *)code))
  368.                                 {
  369.                                 curhd = (YakHandler *)CurObj;
  370.                                 FreeVec(curhd->KeyDef);
  371.                                 curhd->KeyDef = newdef;
  372.                                 }
  373.                         else
  374.                                 PostError(getString(Allocation_ERR));
  375.                         }
  376.                 CloseKeyDefWindow();
  377.                 if (!ShowWindowID(ParentWindowID))
  378.                         ret = RET_QUIT;
  379.                 break;
  380.  
  381.         default:
  382.                 break;
  383.         }
  384.  
  385. return(ret);
  386. }
  387.  
  388. /************************************************************************
  389. ************************  KEYDEFWINDOWHANDLER()  ************************
  390. *************************************************************************
  391. * Hook called by bgui during idcmp msg processing. Used here to scan
  392. * input for codes and qualifiers to put in hotkey description string.
  393. *
  394. *************************************************************************/
  395.  
  396. static SAVEDS ASM ULONG KeyDefWindowHandler(REG(a0) struct Hook *hook, REG(a2) void *obj, REG(a1) void *msg)
  397. {
  398. struct IntuiMessage     *imsg;
  399. UWORD                           code,qual,newqual;
  400.  
  401. imsg = (struct IntuiMessage *)msg;
  402. code = imsg->Code;
  403. qual = imsg->Qualifier;
  404.  
  405. switch(imsg->Class)
  406.         {
  407.         case IDCMP_RAWKEY:
  408.                 if ( (!(code & IECODE_UP_PREFIX) || code == 0xe2 ) && /* a downstroke || capslock up */
  409.                                 ((KeyDef.ykd_Class == HKCLASS_RAWKEY) || (KeyDef.ykd_Class == HKCLASS_RAWMOUSE)) )
  410.                         {
  411.                         if (newqual = IsQualifierPad(code))
  412.                                 {
  413.                                 newqual &= ~KeyDef.ykd_SQual;
  414.                                 newqual &= ~KeyDef.ykd_IQual;
  415.  
  416.                                 /* Toggle Qualifier */
  417.                                 KeyDef.ykd_Qual ^= newqual;
  418.                                 }
  419.                         else
  420.                 {
  421.                                 if (KeyDef.ykd_Class == HKCLASS_RAWKEY)
  422.                                         {
  423.                                         if ((code == KeyDef.ykd_Code) && (KeyDef.ykd_Stroke != HKSTROKE_UP))
  424.                                                 {
  425.                                                 /* Toggle Repeat Keyword */
  426.                                                 if(!(KeyDef.ykd_IQual & IEQUALIFIER_REPEAT))
  427.                                                         KeyDef.ykd_Qual  ^= IEQUALIFIER_REPEAT;
  428.                                                 }
  429.                                         else    /* New key or upstroke mode */
  430.                                                 {
  431.                                                 KeyDef.ykd_Qual  &= ~IEQUALIFIER_KEYS;
  432.                                                 KeyDef.ykd_IQual &= ~IEQUALIFIER_KEYS;
  433.                                                 KeyDef.ykd_Qual  |= qual & IEQUALIFIER_NUMERICPAD;
  434.                                                 KeyDef.ykd_Code   = code;
  435.                                                 }
  436.                                         }
  437.                                 }
  438.  
  439.                         InitKeyDefGadgets();
  440.                         }
  441.                 break;
  442.  
  443.         case IDCMP_MOUSEBUTTONS:
  444.                 if (!(code & IECODE_UP_PREFIX) && /* a downstroke */
  445.                                 ((KeyDef.ykd_Class == HKCLASS_RAWKEY) || (KeyDef.ykd_Class == HKCLASS_RAWMOUSE)) )
  446.                         {
  447.                         switch(code)
  448.                                 {
  449.                                 case IECODE_RBUTTON:
  450.                                         newqual = IEQUALIFIER_RBUTTON;
  451.                                         break;
  452.                                 case IECODE_LBUTTON:
  453.                                         newqual = IEQUALIFIER_LEFTBUTTON;
  454.                                         break;
  455.                                 case IECODE_MBUTTON:
  456.                                         newqual = IEQUALIFIER_MIDBUTTON;
  457.                                         break;
  458.                                 default:
  459.                                         newqual = NO_IEQUALIFIER;
  460.                                         break;
  461.                                 }
  462.  
  463.                         newqual &= ~KeyDef.ykd_IQual;
  464.  
  465.                         if (KeyDef.ykd_Class == HKCLASS_RAWMOUSE)
  466.                                 {
  467.                                 if (KeyDef.ykd_Code == code)
  468.                                         {
  469.                                         KeyDef.ykd_Qual &= ~newqual;
  470.                                         KeyDef.ykd_Code  = NO_IECODE;
  471.                                         }
  472.                                 else
  473.                                         {
  474.                                         KeyDef.ykd_Qual |= newqual;
  475.                                         KeyDef.ykd_Code  = code;
  476.                                         }
  477.                                 }
  478.                         else
  479.                                 KeyDef.ykd_Qual  ^= newqual;
  480.  
  481.                         InitKeyDefGadgets();
  482.                         }
  483.                 break;
  484.  
  485.         default:
  486.                 break;
  487.         }
  488.  
  489. return(0);
  490. }
  491.  
  492. /************************************************************************
  493. *************************  SHOWKEYDEFWINDOW()  **************************
  494. *************************************************************************
  495. * Create and open the KeyDef window and initialize the gadgets to
  496. * reflect current settings. Sets up HandleReturnID function, curwin,
  497. * curwinobj and curwinID. Returns TRUE or FALSE to indicate success.
  498. *
  499. *************************************************************************/
  500.  
  501. BOOL ShowKeyDefWindow(void)
  502. {
  503. if (KeyDefWndObj = (Object *)CreateKeyDefWindow())
  504.         {
  505.         if (KeyDefWnd = WindowOpen(KeyDefWndObj))
  506.                 {
  507.                 /* Disable Yak so that it doesn't interfere with us */
  508.                 BrokerCommand("Yak", CXCMD_DISABLE);
  509.  
  510.                 InitKeyDefGadgets();
  511.                 HandleReturnID = HandleKeyDefReturnID;
  512.                 curwin = KeyDefWnd;
  513.                 curwinobj = KeyDefWndObj;
  514.                 curwinID = KEYDEF_WINDOW;
  515.                 return(TRUE);
  516.                 }
  517.         }
  518.  
  519. CloseKeyDefWindow();
  520. curwin = NULL;
  521. curwinobj = NULL;
  522. wndsigflag = 0L;
  523. appwinsigflag = 0L;
  524. return(FALSE);
  525. }
  526.  
  527.  
  528.